소개

This book is the primary reference for the Rust programming language.

러스트 릴리스

러스트는 6주마다 새로운 언어 릴리스를 발표합니다. 언어의 첫 번째 안정 릴리스는 Rust 1.0.0이었고, 이어서 Rust 1.1.0 등이 출시되었습니다. 도구(rustc, cargo 등) 및 문서(표준 라이브러리, 이 책 등)는 언어 릴리스와 함께 출시됩니다.

최신 Rust 버전에 해당하는 이 책의 최신 릴리스는 항상 https://doc.rust-lang.org/reference/에서 찾을 수 있습니다. 이전 버전은 “reference” 디렉토리 앞에 Rust 버전을 추가하여 찾을 수 있습니다. 예를 들어, Rust 1.49.0에 대한 참조는 https://doc.rust-lang.org/1.49.0/reference/에 있습니다.

참조 가 아닌 것

이 책은 언어 입문서가 아닙니다. 언어에 대한 기본적인 지식이 있다고 가정합니다. 이러한 배경 지식을 습득하는 데 도움이 되는 별도의 책 이 있습니다.

이 책은 또한 언어 배포판에 포함된 표준 라이브러리 에 대한 참조 역할을 하지 않습니다. 해당 라이브러리는 소스 코드에서 문서 속성을 추출하여 별도로 문서화됩니다. 언어 기능이라고 예상할 수 있는 많은 기능이 Rust에서는 라이브러리 기능이므로, 찾고 있는 것이 여기에 없을 수도 있습니다.

마찬가지로, 이 책은 일반적으로 rustc 도구 또는 Cargo의 세부 사항을 문서화하지 않습니다. rustc 에는 자체 책 이 있습니다. Cargo에는 참조 가 포함된 책 이 있습니다. 연결 과 같은 몇몇 페이지는 여전히 rustc 의 작동 방식을 설명합니다.

이 책은 또한 안정적인 Rust에서 사용할 수 있는 기능에 대한 참조 역할만 합니다. 개발 중인 불안정한 기능에 대해서는 불안정 책 을 참조하십시오.

rustc 를 포함한 Rust 컴파일러는 최적화를 수행합니다. 참조는 어떤 최적화가 허용되거나 허용되지 않는지 명시하지 않습니다. 대신, 컴파일된 프로그램을 블랙박스로 생각하십시오. 프로그램을 실행하고 입력을 제공하며 출력을 관찰함으로써만 탐색할 수 있습니다. 그렇게 발생하는 모든 것은 참조가 말하는 바를 따라야 합니다.

이 책을 사용하는 방법

이 책은 순차적으로 읽는다고 가정하지 않습니다. 각 장은 일반적으로 독립적으로 읽을 수 있지만, 언급하지만 논의하지 않는 언어의 측면에 대해서는 다른 장으로 상호 연결됩니다.

이 문서를 읽는 두 가지 주요 방법이 있습니다.

첫 번째는 특정 질문에 답하는 것입니다. 해당 질문에 답하는 장을 알고 있다면 목차에서 해당 장으로 이동할 수 있습니다. 그렇지 않으면 s 를 누르거나 상단 바의 돋보기를 클릭하여 질문과 관련된 키워드를 검색할 수 있습니다. 예를 들어, let 문에서 생성된 임시 값이 언제 삭제되는지 알고 싶다고 가정해 봅시다. 임시 값의 수명 이 표현식 장 에 정의되어 있다는 것을 이미 알고 있지 못했다면, “temporary let“을 검색하면 첫 번째 검색 결과가 해당 섹션으로 안내할 것입니다.

두 번째는 언어의 한 측면에 대한 지식을 일반적으로 향상시키는 것입니다. 이 경우, 더 알고 싶은 것을 볼 때까지 목차를 탐색하고 읽기 시작하십시오. 링크가 흥미로워 보이면 클릭하여 해당 섹션을 읽으십시오.

그렇다고 해서 이 책을 읽는 데 잘못된 방법은 없습니다. 가장 도움이 된다고 생각하는 방식으로 읽으십시오.

규약

모든 기술 서적과 마찬가지로 이 책은 정보를 표시하는 방식에 있어 특정 규칙을 따릅니다. 이러한 규칙은 여기에 문서화되어 있습니다.

• 용어를 정의하는 문장은 해당 용어를 이탤릭체 로 포함합니다. 해당 용어가 해당 장 외부에서 사용될 때마다 일반적으로 이 정의가 있는 섹션에 대한 링크입니다.

  예시 용어 는 정의되는 용어의 예시입니다.

• The main text describes the latest stable edition. Differences to previous editions are separated in edition blocks:

  2018 Edition differences

  Before the 2018 edition, the behavior was this. As of the 2018 edition, the behavior is that.

• Notes that contain useful information about the state of the book or point out useful, but mostly out of scope, information are in note blocks.

  Note

  This is an example note.

• Example blocks show an example that demonstrates some rule or points out some interesting aspect. Some examples may have hidden lines which can be viewed by clicking the eye icon that appears when hovering or tapping the example.

  Example

  This is a code example.

  #![allow(unused)]
  fn main() {
  println!("hello world");
  }

• 언어의 불안정한 동작 또는 언어 기능의 혼란스러운 상호 작용을 보여주는 경고는 특별 경고 상자에 있습니다.

  Warning

  This is an example warning.

• 텍스트 내의 코드 스니펫은 <code> 태그 안에 있습니다.

  더 긴 코드 예제는 구문 강조 표시된 상자에 있으며, 오른쪽 상단 모서리에 복사, 실행 및 숨겨진 줄 표시를 위한 컨트롤이 있습니다.

  // 이것은 숨겨진 줄입니다.
  fn main() {
      println!("이것은 코드 예시입니다");
  }

  모든 예제는 별도로 명시되지 않는 한 최신 에디션을 기준으로 작성되었습니다.

• The grammar and lexical productions are described in the Notation chapter.

• Rule identifiers appear before each language rule enclosed in square brackets. These identifiers provide a way to refer to and link to a specific rule in the language (e.g.). The rule identifier uses periods to separate sections from most general to most specific (destructors.scope.nesting.function-body for example). On narrow screens, the rule name will collapse to display [*].

  규칙 이름을 클릭하면 해당 규칙으로 연결됩니다.

  Warning

  The organization of the rules is currently in flux. For the time being, these identifier names are not stable between releases, and links to these rules may fail if they are changed. We intend to stabilize these once the organization has settled so that links to the rule names will not break between releases.

• Rules that have associated tests will include a Tests link below them (on narrow screens, the link is [T]). Clicking the link will pop up a list of tests, which can be clicked to view the test. For example, see input.encoding.utf8.

  Linking rules to tests is an ongoing effort. See the Test summary chapter for an overview.

기여하기

모든 종류의 기여를 환영합니다.

You can contribute to this book by opening an issue or sending a pull request to the Rust Reference repository. If this book does not answer your question, and you think its answer is in scope of it, please do not hesitate to file an issue or ask about it in the t-lang/doc stream on Zulip. Knowing what people use this book for the most helps direct our attention to making those sections the best that they can be. And of course, if you see anything that is wrong or is non-normative but not specifically called out as such, please also file an issue.

표기법

문법

다음 표기법은 렉서 및 구문 문법 스니펫에서 사용됩니다.

Sequences have a higher precedence than | alternation.

The hard cut operator

The grammar uses ordered alternation: the parser tries alternatives left to right and takes the first that matches. If an alternative fails partway through a sequence, the parser normally backtracks and tries the next alternative. The cut operator (^) prevents this. Once every expression to the left of ^ in a sequence has matched, the rest of the sequence must match or parsing fails unconditionally.

Mizushima et al. introduced cut operators to parsing expression grammars. In the PEG literature, a soft cut prevents backtracking only within the immediately enclosing ordered choice — outer choices can still recover. A hard cut prevents all backtracking past the cut point; failure is definitive. The ^ used in this grammar is a hard cut.

The hard cut operator is necessary because some tokens in Rust begin with a prefix that is itself a valid token. For example, c" begins a C string literal, but c alone is a valid identifier. Without the cut, if c"\0" failed to lex as a C string literal (because null bytes are not allowed in C strings), the parser could backtrack and lex it as two tokens: the identifier c and the string literal "\0". The cut after c" prevents this — once the opening delimiter is recognized, the parser cannot go back. The same reasoning applies to byte literals, byte string literals, raw string literals, and other literals with prefixes that are themselves valid tokens.

문자열 테이블 생성

문법의 일부 규칙(특히 단항 연산자, 이항 연산자 및 키워드)은 인쇄 가능한 문자열 목록으로 단순화된 형태로 제공됩니다. 이러한 경우는 토큰 규칙에 관한 규칙의 하위 집합을 형성하며, DFA에 의해 구동되는 어휘 분석 단계가 파서에 공급하는 결과로 간주되며, 이러한 모든 문자열 테이블 항목의 논리합에 대해 작동합니다.

문법 내에서 monospace 글꼴의 문자열이 나타나면, 이는 해당 문자열 테이블 생성의 단일 멤버에 대한 암시적 참조입니다. 자세한 내용은 토큰 을 참조하십시오.

Grammar visualizations

Below each grammar block is a button to toggle the display of a syntax diagram. A square element is a non-terminal rule, and a rounded rectangle is a terminal.

어휘 구조

입력 형식

이 장에서는 소스 파일이 토큰 시퀀스로 해석되는 방법을 설명합니다.

프로그램이 파일로 구성되는 방법에 대한 설명은 크레이트 및 소스 파일 을 참조하십시오.

소스 인코딩

각 소스 파일은 UTF-8로 인코딩된 유니코드 문자 시퀀스로 해석됩니다.

파일이 유효한 UTF-8이 아니면 오류입니다.

바이트 순서 마크 제거

시퀀스의 첫 번째 문자가 U+FEFF(바이트 순서 마크)이면 제거됩니다.

CRLF 정규화

Each pair of characters U+000D (CR) immediately followed by U+000A (LF) is replaced by a single U+000A (LF). This happens once, not repeatedly, so after the normalization, there can still exist U+000D (CR) immediately followed by U+000A (LF) in the input (e.g. if the raw input contained “CR CR LF LF”).

U+000D (CR) 문자의 다른 발생은 그대로 유지됩니다(이들은 공백 으로 처리됩니다).

쉬뱅 제거

남은 시퀀스가 #! 문자로 시작하면, 첫 번째 U+000A (LF)까지의 문자가 시퀀스에서 제거됩니다.

예를 들어, 다음 파일의 첫 번째 줄은 무시됩니다:

#!/usr/bin/env rustx

fn main() {
    println!("안녕하세요!");
}

예외적으로, #! 문자 뒤에 (중간에 있는 주석 이나 공백 을 무시하고) [ 토큰이 오면 아무것도 제거되지 않습니다. 이는 소스 파일 시작 부분에 있는 내부 속성 이 제거되는 것을 방지합니다.

토큰화

결과 문자 시퀀스는 이 장의 나머지 부분에 설명된 대로 토큰으로 변환됩니다.

키워드

러스트는 키워드를 세 가지 범주로 나눕니다:

• 엄격
• 예약됨
• 약함

엄격한 키워드

이 키워드는 올바른 컨텍스트에서만 사용할 수 있습니다. 다음 이름으로는 사용할 수 없습니다:

• 아이템
• 변수 및 함수 매개변수
• 필드 및 변형
• 타입 매개변수
• 라이프타임 매개변수 또는 루프 레이블
• 매크로 또는 속성
• 매크로 플레이스홀더
• 크레이트

The following keywords are in all editions:

• _
• as
• async
• await
• break
• const
• continue
• crate
• dyn
• else
• enum
• extern
• false
• fn
• for
• if
• impl
• in
• let
• loop
• match
• mod
• move
• mut
• pub
• ref
• return
• self
• Self
• static
• struct
• super
• trait
• true
• type
• unsafe
• use
• where
• while

예약된 키워드

이 키워드들은 아직 사용되지 않지만, 미래를 위해 예약되어 있습니다. 이 키워드들은 엄격한 키워드와 동일한 제약 조건을 가집니다. 이 키워드들을 사용하지 못하게 함으로써 현재 프로그램이 미래 버전의 Rust와 호환되도록 하기 위함입니다.

• abstract
• become
• box
• do
• final
• gen
• macro
• override
• priv
• try
• typeof
• unsized
• virtual
• yield

약한 키워드

이 키워드는 특정 컨텍스트에서만 특별한 의미를 가집니다. 예를 들어, union 이라는 이름으로 변수나 메서드를 선언할 수 있습니다.

• 'static
• macro_rules
• raw
• safe
• union

• macro_rules 는 사용자 정의 매크로 를 생성하는 데 사용됩니다.

• union 은 유니온 을 선언하는 데 사용되며, 유니온 선언에서 사용될 때만 키워드입니다.

• 'static 은 정적 라이프타임에 사용되며, 제네릭 라이프타임 매개변수 또는 루프 레이블 로 사용될 수 없습니다.

  // error[E0262]: 잘못된 라이프타임 매개변수 이름: `'static`
  fn invalid_lifetime_parameter<'static>(s: &'static str) -> &'static str { s }
  

• safe 는 함수와 정적에 사용되며, 외부 블록 에서 의미를 가집니다.

• raw 는 원시 차용 연산자 에 사용되며, 원시 차용 연산자 형식(예: &raw const expr 또는 &raw mut expr)과 일치할 때만 키워드입니다.

식별자

Identifiers follow the specification in Unicode Standard Annex #31 for Unicode version 17.0, with the additions described below. Some examples of identifiers:

• foo
• _identifier
• r#true
• Москва
• 東京

UAX #31에서 사용된 프로필은 다음과 같습니다:

• 시작 := XID_Start, 더하기 밑줄 문자 (U+005F)
• 계속 := XID_Continue
• 중간 := 비어 있음

식별자는 아래 원시 식별자 에 설명된 r# 접두사 없이 엄격한 또는 예약된 키워드일 수 없습니다.

제로 너비 비결합자(ZWNJ U+200C) 및 제로 너비 결합자(ZWJ U+200D) 문자는 식별자에 허용되지 않습니다.

식별자는 다음 상황에서 XID_Start 및 XID_Continue 의 ASCII 서브셋으로 제한됩니다:

• extern crate declarations (except the AsClause identifier)
• 경로 에서 참조되는 외부 크레이트 이름
• path 속성 없이 파일 시스템에서 로드된 모듈 이름
• no_mangle 속성 항목
• 외부 블록 의 아이템 이름

정규화

Identifiers are normalized using Normalization Form C (NFC) as defined in Unicode Standard Annex #15. Two identifiers are equal if their NFC forms are equal.

절차적 및 선언적 매크로는 입력에서 정규화된 식별자를 받습니다.

원시 식별자

원시 식별자는 일반 식별자와 같지만 r# 접두사가 붙습니다. (r# 접두사는 실제 식별자의 일부로 포함되지 않습니다.)

일반 식별자와 달리, 원시 식별자는 RAW_IDENTIFIER 에 대해 위에 나열된 키워드를 제외한 모든 엄격하거나 예약된 키워드일 수 있습니다.

It is an error to use the RESERVED_RAW_IDENTIFIER token.

주석

비 문서 주석

주석은 일반적인 C++ 스타일의 라인 (//) 및 블록 (/* ... */) 주석 형식을 따릅니다. 중첩된 블록 주석이 지원됩니다.

비 문서 주석은 공백의 한 형태로 해석됩니다.

문서 주석

정확히 세 개의 슬래시(///)로 시작하는 라인 문서 주석과 블록 문서 주석(/** ... */), 이 두 가지 외부 문서 주석은 doc 속성 을 위한 특별한 구문으로 해석됩니다.

That is, they are equivalent to writing #[doc="..."] around the body of the comment, i.e., /// Foo turns into #[doc=" Foo"] and /** Bar */ turns into #[doc=" Bar "]. They must therefore appear before something that accepts an outer attribute.

//! 로 시작하는 라인 주석과 /*! ... */ 블록 주석은 뒤따르는 항목이 아닌 주석의 부모에 적용되는 문서 주석입니다.

즉, 이들은 주석 본문 주위에 #![doc="..."] 를 작성하는 것과 동일합니다. //! 주석은 일반적으로 소스 파일을 차지하는 모듈을 문서화하는 데 사용됩니다.

문서 주석에는 U+000D (CR) 문자가 허용되지 않습니다.

예시

#![allow(unused)]
fn main() {
//! 이 크레이트의 암시적 익명 모듈에 적용되는 문서 주석

pub mod outer_module {

    //!  - 내부 라인 문서
    //!! - 여전히 내부 라인 문서 (하지만 시작에 느낌표가 있음)

    /*!  - 내부 블록 문서 */
    /*!! - 여전히 내부 블록 문서 (하지만 시작에 느낌표가 있음) */

    //   - 단순 주석
    ///  - 외부 라인 문서 (정확히 슬래시 3개)
    //// - 단순 주석

    /*   - 단순 주석 */
    /**  - 외부 블록 문서 (정확히) 별표 2개 */
    /*** - 단순 주석 */

    pub mod inner_module {}

    pub mod nested_comments {
        /* Rust에서는 /* /* 주석을 중첩할 수 있습니다 */ */ */

        // 세 가지 유형의 블록 주석은 다른 유형 내에 포함되거나 중첩될 수 있습니다:

        /*   /* */  /** */  /*! */  */
        /*!  /* */  /** */  /*! */  */
        /**  /* */  /** */  /*! */  */
        pub mod dummy_item {}
    }

    pub mod degenerate_cases {
        // 비어 있는 내부 라인 문서
        //!

        // 비어 있는 내부 블록 문서
        /*!*/

        // 비어 있는 라인 주석
        //

        // 비어 있는 외부 라인 문서
        ///

        // 비어 있는 블록 주석
        /**/

        pub mod dummy_item {}

        // 비어 있는 2-별표 블록은 문서 블록이 아니라 블록 주석입니다.
        /***/

    }

    /* 다음은 외부 문서 주석이 문서를 받을 항목을 요구하기 때문에 허용되지 않습니다 */

    /// 내 항목은 어디에 있나요?
  mod boo {}
}
}

공백

Whitespace is any non-empty string containing only characters that have the Pattern_White_Space Unicode property.

Rust는 “자유 형식” 언어입니다. 즉, 모든 형태의 공백은 문법에서 토큰 을 구분하는 역할만 하며, 의미론적 중요성은 없습니다.

Rust 프로그램은 각 공백 요소가 단일 공백 문자처럼 다른 유효한 공백 요소로 대체되어도 동일한 의미를 가집니다.

토큰

토큰은 정규 (비재귀) 언어로 정의된 문법의 기본 생성물입니다. Rust 소스 입력은 다음 종류의 토큰으로 나눌 수 있습니다:

• 키워드
• 식별자
• 리터럴
• 라이프타임
• 구두점
• 구분자

이 문서의 문법에서 “단순” 토큰은 문자열 테이블 생성 형식으로 주어지며, monospace 글꼴로 나타납니다.

리터럴

리터럴은 리터럴 표현식 에 사용되는 토큰입니다.

예시

문자와 문자열

ASCII 이스케이프

바이트 이스케이프

유니코드 이스케이프

인용 이스케이프

숫자

접미사

접미사는 리터럴의 주요 부분 뒤에 오는 문자 시퀀스(중간 공백 없이)로, 비원시 식별자 또는 키워드와 동일한 형태입니다.

어떤 종류의 리터럴(문자열, 정수 등)이든 어떤 접미사와 함께 사용되어도 유효한 토큰입니다.

어떤 접미사가 붙은 리터럴 토큰도 오류 없이 매크로에 전달될 수 있습니다. 매크로 자체는 그러한 토큰을 해석하는 방법과 오류를 발생시킬지 여부를 결정합니다. 특히, 예제 매크로의 literal 프래그먼트 지정자는 임의의 접미사가 붙은 리터럴 토큰과 일치합니다.

#![allow(unused)]
fn main() {
macro_rules! blackhole { ($tt:tt) => () }
macro_rules! blackhole_lit { ($l:literal) => () }

blackhole!("string"suffix); // OK
blackhole_lit!(1suffix); // OK
}

그러나 리터럴 표현식 또는 패턴으로 해석되는 리터럴 토큰의 접미사는 제한됩니다. 비숫자 리터럴 토큰의 모든 접미사는 거부되며, 숫자 리터럴 토큰은 아래 목록의 접미사만 허용됩니다.

문자 및 문자열 리터럴

문자 리터럴

문자 리터럴 은 두 개의 U+0027(작은따옴표) 문자 안에 묶인 단일 유니코드 문자입니다. 단, U+0027 자체는 선행하는 U+005C 문자(\)로 이스케이프 되어야 합니다.

문자열 리터럴

문자열 리터럴 은 두 개의 U+0022(큰따옴표) 문자 안에 묶인 모든 유니코드 문자 시퀀스입니다. 단, U+0022 자체는 선행하는 U+005C 문자(\)로 이스케이프 되어야 합니다.

Line-breaks, represented by the character U+000A (LF), are allowed in string literals. The character U+000D (CR) may not appear in a string literal. When an unescaped U+005C character (\) occurs immediately before a line break, the line break does not appear in the string represented by the token. See String continuation escapes for details.

문자 이스케이프

문자 또는 비원시 문자열 리터럴에는 몇 가지 추가 이스케이프 가 사용 가능합니다. 이스케이프는 U+005C(\)로 시작하며 다음 형식 중 하나로 이어집니다:

• 7비트 코드 포인트 이스케이프 는 U+0078(x)로 시작하며, 0x7F 까지의 값을 가진 정확히 두 개의 16진수 숫자 가 뒤따릅니다. 이는 제공된 16진수 값과 동일한 값을 가진 ASCII 문자를 나타냅니다. 더 높은 값은 유니코드 코드 포인트를 의미하는지 바이트 값을 의미하는지 모호하기 때문에 허용되지 않습니다.

• A 24-bit code point escape starts with U+0075 (u) and is followed by up to six hex digits surrounded by braces U+007B ({) and U+007D (}). It denotes the Unicode code point equal to the provided hex value. The value must be a valid Unicode scalar value.

• 공백 이스케이프 는 U+006E(n), U+0072(r), 또는 U+0074(t) 문자 중 하나이며, 각각 유니코드 값 U+000A(LF), U+000D(CR) 또는 U+0009(HT)를 나타냅니다.

• 널 이스케이프 는 U+0030(0) 문자이며 유니코드 값 U+0000(NUL)을 나타냅니다.

• The backslash escape is the character U+005C (\) which must be escaped in order to denote itself.

원시 문자열 리터럴

원시 문자열 리터럴은 어떤 이스케이프도 처리하지 않습니다. 이들은 U+0072(r) 문자로 시작하며, 256개 미만의 U+0023(#) 문자와 U+0022(큰따옴표) 문자가 뒤따릅니다.

원시 문자열 본문 은 U+000D(CR)를 제외한 모든 유니코드 문자 시퀀스를 포함할 수 있습니다. 이스케이프는 다른 U+0022(큰따옴표) 문자로만 종료되며, 여는 U+0022(큰따옴표) 문자 앞에 있던 것과 동일한 수의 U+0023(#) 문자가 뒤따릅니다.

원시 문자열 본문에 포함된 모든 유니코드 문자는 그 자체를 나타내며, U+0022(큰따옴표) 문자(원시 문자열 리터럴을 시작하는 데 사용된 U+0023(#) 문자 수만큼 이상이 뒤따르지 않는 경우) 또는 U+005C(\)는 특별한 의미를 갖지 않습니다.

문자열 리터럴 예시:

#![allow(unused)]
fn main() {
"foo"; r"foo";                     // foo
"\"foo\""; r#""foo""#;             // "foo"

"foo #\"# bar";
r##"foo #"# bar"##;                // foo #"# bar

"\x52"; "R"; r"R";                 // R
"\\x52"; r"\x52";                  // \x52
}

바이트 및 바이트 문자열 리터럴

바이트 리터럴

바이트 리터럴 은 U+0062(b)와 U+0027(작은따옴표) 문자로 시작하고 U+0027 문자로 끝나는 단일 ASCII 문자(U+0000 에서 U+007F 범위) 또는 단일 이스케이프 입니다. U+0027 문자가 리터럴 내에 있으면 선행하는 U+005C(\) 문자로 이스케이프 되어야 합니다. 이는 u8 부호 없는 8비트 정수 숫자 리터럴 과 동일합니다.

바이트 문자열 리터럴

비원시 바이트 문자열 리터럴 은 U+0062(b)와 U+0022(큰따옴표) 문자로 시작하고 U+0022 문자로 끝나는 ASCII 문자와 이스케이프 시퀀스입니다. U+0022 문자가 리터럴 내에 있으면 선행하는 U+005C(\) 문자로 이스케이프 되어야 합니다. 또는 바이트 문자열 리터럴은 아래에 정의된 원시 바이트 문자열 리터럴 일 수 있습니다.

Line-breaks, represented by the character U+000A (LF), are allowed in byte string literals. The character U+000D (CR) may not appear in a byte string literal. When an unescaped U+005C character (\) occurs immediately before a line break, the line break does not appear in the string represented by the token. See String continuation escapes for details.

바이트 또는 비원시 바이트 문자열 리터럴에는 몇 가지 추가 이스케이프 가 사용 가능합니다. 이스케이프는 U+005C(\)로 시작하며 다음 형식 중 하나로 이어집니다:

• 바이트 이스케이프 는 U+0078(x)로 시작하며, 정확히 두 개의 16진수 숫자 가 뒤따릅니다. 이는 제공된 16진수 값과 동일한 바이트를 나타냅니다.

• 공백 이스케이프 는 U+006E(n), U+0072(r), 또는 U+0074(t) 문자 중 하나이며, 각각 바이트 값 0x0A(ASCII LF), 0x0D(ASCII CR) 또는 0x09(ASCII HT)를 나타냅니다.

• 널 이스케이프 는 U+0030(0) 문자이며 바이트 값 0x00(ASCII NUL)을 나타냅니다.

• The backslash escape is the character U+005C (\) which must be escaped in order to denote its ASCII encoding 0x5C.

원시 바이트 문자열 리터럴

원시 바이트 문자열 리터럴은 어떤 이스케이프도 처리하지 않습니다. 이들은 U+0062(b) 문자로 시작하고 U+0072(r) 문자가 뒤따르며, 256개 미만의 U+0023(#) 문자와 U+0022(큰따옴표) 문자가 뒤따릅니다.

원시 문자열 본문 은 U+000D(CR)를 제외한 모든 ASCII 문자 시퀀스를 포함할 수 있습니다. 이스케이프는 다른 U+0022(큰따옴표) 문자로만 종료되며, 여는 U+0022(큰따옴표) 문자 앞에 있던 것과 동일한 수의 U+0023(#) 문자가 뒤따릅니다. 원시 바이트 문자열 리터럴은 비 ASCII 바이트를 포함할 수 없습니다.

원시 문자열 본문에 포함된 모든 문자는 ASCII 인코딩을 나타내며, U+0022(큰따옴표) 문자(원시 문자열 리터럴을 시작하는 데 사용된 U+0023(#) 문자 수만큼 이상이 뒤따르지 않는 경우) 또는 U+005C(\)는 특별한 의미를 갖지 않습니다.

바이트 문자열 리터럴 예시:

#![allow(unused)]
fn main() {
b"foo"; br"foo";                     // foo
b"\"foo\""; br#""foo""#;             // "foo"

b"foo #\"# bar";
br##"foo #"# bar"##;                 // foo #"# bar

b"\x52"; b"R"; br"R";                // R
b"\\x52"; br"\x52";                  // \x52
}

C 문자열 및 원시 C 문자열 리터럴

C 문자열 리터럴

C 문자열 리터럴 은 U+0063(c)과 U+0022(큰따옴표) 문자로 시작하고 U+0022 문자로 끝나는 유니코드 문자와 이스케이프 시퀀스입니다. U+0022 문자가 리터럴 내에 있으면 선행하는 U+005C(\) 문자로 이스케이프 되어야 합니다. 또는 C 문자열 리터럴은 아래에 정의된 원시 C 문자열 리터럴 일 수 있습니다.

C 문자열은 바이트 0x00 으로 암시적으로 종료되므로, C 문자열 리터럴 c"" 는 바이트 문자열 리터럴 b"\x00" 에서 &CStr 를 수동으로 구성하는 것과 동일합니다. 암시적 종료자를 제외하고, 바이트 0x00 은 C 문자열 내에서 허용되지 않습니다.

Line-breaks, represented by the character U+000A (LF), are allowed in C string literals. The character U+000D (CR) may not appear in a C string literal. When an unescaped U+005C character (\) occurs immediately before a line break, the line break does not appear in the string represented by the token. See String continuation escapes for details.

비원시 C 문자열 리터럴에는 몇 가지 추가 이스케이프 가 사용 가능합니다. 이스케이프는 U+005C(\)로 시작하며 다음 형식 중 하나로 이어집니다:

• 바이트 이스케이프 는 U+0078(x)로 시작하며, 정확히 두 개의 16진수 숫자 가 뒤따릅니다. 이는 제공된 16진수 값과 동일한 바이트를 나타냅니다.

• 24비트 코드 포인트 이스케이프 는 U+0075(u)로 시작하고 중괄호 U+007B({) 및 U+007D(})로 둘러싸인 최대 6개의 16진수 숫자 가 뒤따릅니다. 제공된 16진수 값과 동일한 유니코드 코드 포인트를 나타내며 UTF-8로 인코딩됩니다.

• 공백 이스케이프 는 U+006E(n), U+0072(r), 또는 U+0074(t) 문자 중 하나이며, 각각 바이트 값 0x0A(ASCII LF), 0x0D(ASCII CR) 또는 0x09(ASCII HT)를 나타냅니다.

• The backslash escape is the character U+005C (\) which must be escaped in order to denote its ASCII encoding 0x5C.

C 문자열은 정의된 인코딩이 없는 바이트를 나타내지만 C 문자열 리터럴에는 U+007F 이상의 유니코드 문자가 포함될 수 있습니다. 이러한 문자는 해당 문자의 UTF-8 표현 바이트로 대체됩니다.

다음 C 문자열 리터럴은 동일합니다.

#![allow(unused)]
fn main() {
c"æ";        // 라틴어 소문자 AE (U+00E6)
c"\u{00E6}";
c"\xC3\xA6";
}

원시 C 문자열 리터럴

원시 C 문자열 리터럴은 어떤 이스케이프도 처리하지 않습니다. U+0063(c) 문자로 시작하고 U+0072(r) 문자가 뒤따르며, 256자 미만의 U+0023(#) 문자와 U+0022(큰따옴표) 문자가 뒤따릅니다.

원시 C 문자열 본문 은 U+0000(NUL) 및 U+000D(CR) 이외의 모든 유니코드 문자 시퀀스를 포함할 수 있습니다. 다른 U+0022(큰따옴표) 문자로만 종료되며, 여는 U+0022(큰따옴표) 문자 앞에 있던 것과 동일한 수의 U+0023(#) 문자가 뒤따릅니다.

원시 C 문자열 본문에 포함된 모든 문자는 UTF-8 인코딩으로 자신을 나타냅니다. U+0022(큰따옴표) 문자(원시 C 문자열 리터럴을 시작하는 데 사용된 U+0023(#) 문자 수만큼 이상 뒤따르지 않는 경우) 또는 U+005C(\)는 특별한 의미를 갖지 않습니다.

C 문자열 및 원시 C 문자열 리터럴의 예

#![allow(unused)]
fn main() {
c"foo"; cr"foo";                     // foo
c"\"foo\""; cr#""foo""#;             // "foo"

c"foo #\"# bar";
cr##"foo #"# bar"##;                 // foo #"# bar

c"\x52"; c"R"; cr"R";                // R
c"\\x52"; cr"\x52";                  // \x52
}

숫자 리터럴

숫자 리터럴 은 정수 리터럴 또는 부동 소수점 리터럴 입니다. 두 종류의 리터럴을 인식하는 문법은 혼합되어 있습니다.

정수 리터럴

정수 리터럴 은 네 가지 형태 중 하나를 갖습니다.

• 십진수 리터럴 은 십진수 숫자 로 시작하고 십진수 숫자 와 밑줄 의 혼합으로 이어집니다.

• 16진수 리터럴 은 문자 시퀀스 U+0030 U+0078(0x)로 시작하고 16진수 숫자와 밑줄의 혼합(최소 한 자리 이상)으로 이어집니다.

• 8진수 리터럴 은 문자 시퀀스 U+0030 U+006F(0o)로 시작하고 8진수 숫자와 밑줄의 혼합(최소 한 자리 이상)으로 이어집니다.

• 2진수 리터럴 은 문자 시퀀스 U+0030 U+0062(0b)로 시작하고 2진수 숫자와 밑줄의 혼합(최소 한 자리 이상)으로 이어집니다.

모든 리터럴과 마찬가지로 정수 리터럴 뒤에는 위에서 설명한 대로 접미사가 (공백 없이) 바로 올 수 있습니다. 접미사는 e 또는 E 로 시작할 수 없습니다. 이는 부동 소수점 리터럴의 지수로 해석되기 때문입니다. 이러한 접미사의 효과에 대해서는 정수 리터럴 표현식 을 참조하십시오.

리터럴 표현식으로 허용되는 정수 리터럴의 예:

#![allow(unused)]
fn main() {
#![allow(overflowing_literals)]
123;
123i32;
123u32;
123_u32;

0xff;
0xff_u8;
0x01_f32; // 정수 7986, 부동 소수점 1.0 아님
0x01_e3;  // 정수 483, 부동 소수점 1000.0 아님

0o70;
0o70_i16;

0b1111_1111_1001_0000;
0b1111_1111_1001_0000i64;
0b________1;

0usize;

// 이것들은 타입에 비해 너무 크지만, 리터럴 표현식으로 허용됩니다.
128_i8;
256_u8;

// 이것은 정수 리터럴이며, 부동 소수점 리터럴 표현식으로 허용됩니다.
5f32;
}

예를 들어 -1i8 은 - 와 1i8 의 두 토큰으로 분석됩니다.

리터럴 표현식으로 허용되지 않는 정수 리터럴의 예:

#![allow(unused)]
fn main() {
#[cfg(false)] {
0invalidSuffix;
123AFB43;
0b010a;
0xAB_CD_EF_GH;
0b1111_f32;
}
}

튜플 인덱스

A tuple index is used to refer to the fields of tuples, tuple structs, and tuple enum variants.

튜플 인덱스는 리터럴 토큰과 직접 비교됩니다. 튜플 인덱스는 0 으로 시작하고 각 연속 인덱스는 값을 1씩 10진수 값으로 증가시킵니다. 따라서 10진수 값만 일치하며 값에 추가 0 접두사 문자가 없어야 합니다.

Tuple indices may not include any suffixes (such as usize).

#![allow(unused)]
fn main() {
let example = (개, "cat", 말);
let dog = example.0;
let cat = example.1;
// 다음 예제는 유효하지 않습니다.
let cat = example.01;  // 오류: `01` 이라는 필드가 없습니다
let horse = example.0b10;  // 오류: `0b10` 이라는 필드가 없습니다
let unicorn = example.0usize; // ERROR suffixes on a tuple index are invalid
let underscore = example.0_0; // ERROR no field `0_0` on type `(&str, &str, &str)`
}

부동 소수점 리터럴

부동 소수점 리터럴 은 두 가지 형태 중 하나를 갖습니다.

• 십진수 리터럴 뒤에 마침표 문자 U+002E(.)가 옵니다. 선택적으로 다른 십진수 리터럴과 선택적 지수 가 뒤따를 수 있습니다.
• 단일 십진수 리터럴 뒤에 지수 가 옵니다.

정수 리터럴과 마찬가지로 부동 소수점 리터럴 뒤에는 접미사가 올 수 있습니다. 단, 접미사 앞부분이 U+002E(.)로 끝나지 않아야 합니다. 리터럴에 지수가 포함되지 않은 경우 접미사는 e 또는 E 로 시작할 수 없습니다. 이러한 접미사의 효과에 대해서는 부동 소수점 리터럴 표현식 을 참조하십시오.

리터럴 표현식으로 허용되는 부동 소수점 리터럴의 예:

#![allow(unused)]
fn main() {
123.0f64;
0.1f64;
0.1f32;
12E+99_f64;
let x: f64 = 2.;
}

This last example is different because it is not possible to use the suffix syntax with a floating point literal ending in a period. 2.f64 would attempt to call a method named f64 on 2.

예를 들어 -1.0 은 - 와 1.0 의 두 토큰으로 분석됩니다.

리터럴 표현식으로 허용되지 않는 부동 소수점 리터럴의 예:

#![allow(unused)]
fn main() {
#[cfg(false)] {
2.0f80;
2e5f80;
2e5e6;
2.0e5e6;
1.3e10u64;
}
}

숫자 리터럴과 유사한 예약된 형식

숫자 리터럴과 유사한 다음 어휘 형식은 예약된 형식 입니다. 이들이 제기하는 모호성 때문에 토크나이저는 이를 별도의 토큰으로 해석하는 대신 거부합니다.

• 접미사가 없는 2진수 또는 8진수 리터럴 뒤에 공백 없이 해당 기수 범위를 벗어나는 10진수 숫자가 오는 경우.

• 접미사가 없는 2진수, 8진수 또는 16진수 리터럴 뒤에 공백 없이 마침표 문자가 오는 경우(마침표 뒤에 오는 내용에 대한 제한은 부동 소수점 리터럴과 동일).

• 접미사가 없는 2진수 또는 8진수 리터럴 뒤에 공백 없이 e 또는 E 문자가 오는 경우.

• 기수 접두사 중 하나로 시작하지만 유효한 2진수, 8진수 또는 16진수 리터럴이 아닌 입력 (숫자를 포함하지 않기 때문에).

• 지수에 숫자가 없는 부동 소수점 리터럴 형식을 갖는 입력.

예약된 형식의 예:

#![allow(unused)]
fn main() {
0b0102;  // 이것은 `0b010` 뒤에 `2` 가 오는 것이 아닙니다
0o1279;  // 이것은 `0o127` 뒤에 `9` 가 오는 것이 아닙니다
0x80.0;  // 이것은 `0x80` 뒤에 `.` 와 `0` 이 오는 것이 아닙니다
0b101e;  // 이것은 접미사가 붙은 리터럴이 아니거나, `0b101` 뒤에 `e` 가 오는 것이 아닙니다
0b;      // 이것은 정수 리터럴이 아니거나, `0` 뒤에 `b` 가 오는 것이 아닙니다
0b_;     // 이것은 정수 리터럴이 아니거나, `0` 뒤에 `b_` 가 오는 것이 아닙니다
2e;      // 이것은 부동 소수점 리터럴이 아니거나, `2` 뒤에 `e` 가 오는 것이 아닙니다
2.0e;    // 이것은 부동 소수점 리터럴이 아니거나, `2.0` 뒤에 `e` 가 오는 것이 아닙니다
2em;     // 이것은 접미사가 붙은 리터럴이 아니거나, `2` 뒤에 `em` 이 오는 것이 아닙니다
2.0em;   // 이것은 접미사가 붙은 리터럴이 아니거나, `2.0` 뒤에 `em` 이 오는 것이 아닙니다
}

라이프타임과 루프 레이블

Lifetime parameters and loop labels use LIFETIME_OR_LABEL tokens. Any LIFETIME_TOKEN will be accepted by the lexer, and for example, can be used in macros.

원시 라이프타임은 일반 라이프타임과 같지만 식별자 앞에 r# 접두사가 붙습니다. (r# 접두사는 실제 라이프타임의 일부로 포함되지 않습니다.)

일반 라이프타임과 달리 원시 라이프타임은 RAW_LIFETIME 에 대해 위에 나열된 키워드를 제외한 모든 엄격하거나 예약된 키워드일 수 있습니다.

It is an error to use the RESERVED_RAW_LIFETIME token.

구두점

Punctuation tokens are used as operators, separators, and other parts of the grammar.

구분자

대괄호 구두점은 문법의 다양한 부분에서 사용됩니다. 여는 대괄호는 항상 닫는 대괄호와 짝을 이루어야 합니다. 대괄호와 그 안의 토큰은 매크로 에서 “토큰 트리“라고 합니다. 세 가지 유형의 대괄호는 다음과 같습니다.

Reserved tokens

Several token forms are reserved for future use or to avoid confusion. It is an error for the source input to match one of these forms.

예약된 접두사

예약된 접두사 로 알려진 일부 어휘 형식은 향후 사용을 위해 예약되어 있습니다.

Source input which would otherwise be lexically interpreted as a non-raw identifier (or a keyword) which is immediately followed by a #, ', or " character (without intervening whitespace) is identified as a reserved prefix.

원시 식별자, 원시 문자열 리터럴 및 원시 바이트 문자열 리터럴에는 # 문자가 포함될 수 있지만 예약된 접두사를 포함하는 것으로 해석되지 않습니다.

마찬가지로 원시 문자열 리터럴, 바이트 리터럴, 바이트 문자열 리터럴, 원시 바이트 문자열 리터럴, C 문자열 리터럴 및 원시 C 문자열 리터럴에 사용되는 r, b, br, c 및 cr 접두사는 예약된 접두사로 해석되지 않습니다.

Source input which would otherwise be lexically interpreted as a non-raw lifetime (or a keyword) which is immediately followed by a # character (without intervening whitespace) is identified as a reserved lifetime prefix.

예약된 가드

예약된 가드는 향후 사용을 위해 예약된 구문이며 사용하면 컴파일 오류가 발생합니다.

The reserved guarded string literal is a token of one or more U+0023 (#) immediately followed by a STRING_LITERAL.

예약된 파운드 는 두 개 이상의 U+0023(#) 토큰입니다.

1. 동일한 리터럴의 각 면에 있는 # 의 수는 동일해야 합니다. ↩

2. 모든 숫자 리터럴은 _ 를 시각적 구분자로 허용합니다: 1_234.0E+18f64 ↩

3. See lex.token.literal.char-escape.unicode. ↩

매크로

Rust의 기능과 구문은 매크로라는 사용자 지정 정의로 확장할 수 있습니다. 이름이 주어지고 some_extension!(...) 과 같은 일관된 구문을 통해 호출됩니다.

새 매크로를 정의하는 두 가지 방법이 있습니다.

• 예제를 통한 매크로 는 더 높은 수준의 선언적 방식으로 새로운 구문을 정의합니다.
• 절차적 매크로 는 입력 토큰에 대해 작동하는 함수를 사용하여 함수와 유사한 매크로, 사용자 지정 파생 및 사용자 지정 속성을 정의합니다.

Macro invocation

매크로 호출은 컴파일 타임에 매크로를 확장하고 호출을 매크로의 결과로 바꿉니다. 다음과 같은 상황에서 매크로를 호출할 수 있습니다.

• 표현식 및 문

• 패턴

• 유형

• 항목 포함 연관 항목

• macro_rules 트랜스크라이버

• 외부 블록

When used as an item or a statement, the MacroInvocationSemi form is used where a semicolon is required at the end when not using curly braces. Visibility qualifiers are never allowed before a macro invocation or macro_rules definition.

#![allow(unused)]
fn main() {
// 표현식으로 사용됩니다.
let x = vec![1,2,3];

// 문으로 사용됩니다.
println!("안녕하세요!");

// 패턴에서 사용됩니다.
macro_rules! pat {
    ($i:ident) => (Some($i))
}

if let pat!(x) = Some(1) {
    assert_eq!(x, 1);
}

// 유형에서 사용됩니다.
macro_rules! Tuple {
    { $A:ty, $B:ty } => { ($A, $B) };
}

type N2 = Tuple!(i32, i32);

// 항목으로 사용됩니다.
use std::cell::RefCell;
thread_local!(static FOO: RefCell<u32> = RefCell::new(1));

// Used as an associated item.
macro_rules! const_maker {
    ($t:ty, $v:tt) => { const CONST: $t = $v; };
}
trait T {
    const_maker!{i32, 7}
}

// Macro calls within macros.
macro_rules! example {
    () => { println!("매크로 내의 매크로 호출!") };
}
// 외부 매크로 `example` 이 확장된 후, 내부 매크로 `println` 이 확장됩니다.
example!();
}

Macros invocations can be resolved via two kinds of scopes:

• 텍스트 범위
  • Textual scope macro_rules
• Path-based scope
  • Path-based scope macro_rules
  • Procedural macros

Macros by example